home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / gst-0.10 / gst / extend / leveller.py < prev    next >
Encoding:
Python Source  |  2009-02-21  |  9.7 KB  |  286 lines
  1. # -*- Mode: Python -*-
  2. # vi:si:et:sw=4:sts=4:ts=4
  3. #
  4. # GStreamer python bindings
  5. # Copyright (C) 2005 Thomas Vander Stichele <thomas at apestaart dot org>
  6.  
  7. # This library is free software; you can redistribute it and/or
  8. # modify it under the terms of the GNU Lesser General Public
  9. # License as published by the Free Software Foundation; either
  10. # version 2.1 of the License, or (at your option) any later version.
  11. # 
  12. # This library is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. # Lesser General Public License for more details.
  16. # 
  17. # You should have received a copy of the GNU Lesser General Public
  18. # License along with this library; if not, write to the Free Software
  19. # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20.  
  21. import os
  22. import sys
  23. import math
  24.  
  25. import gobject
  26. import pygst
  27. pygst.require('0.10')
  28. import gst
  29.  
  30. import utils
  31. from pygobject import gsignal
  32.  
  33. import sources
  34. from sources import EOS, ERROR, UNKNOWN_TYPE, WRONG_TYPE
  35.  
  36. class Leveller(gst.Pipeline):
  37.     """
  38.     I am a pipeline that calculates RMS values and mix-in/out points.
  39.     I will signal 'done' when I'm done scanning the file, with return value
  40.     EOS, ERROR, UNKNOWN_TYPE, or WRONG_TYPE from gst.extend.sources
  41.     """
  42.  
  43.     gsignal('done', str)
  44.  
  45.     def __init__(self, filename, threshold=-9.0):
  46.         gst.Pipeline.__init__(self)
  47.  
  48.         self._filename = filename
  49.  
  50.         self._thresholddB = threshold
  51.         self._threshold = math.pow(10, self._thresholddB / 10.0)
  52.  
  53.         self._source = sources.AudioSource(filename)
  54.         self._source.connect('done', self._done_cb)
  55.  
  56.         self._level = gst.element_factory_make("level")
  57.  
  58.         self._fakesink = gst.element_factory_make("fakesink")
  59.  
  60.         self.add(self._source, self._level, self._fakesink)
  61.         self._source.connect("pad-added", self._sourcePadAddedCb)
  62.         self._level.link(self._fakesink)
  63.  
  64.         # temporary values for each timepoint
  65.         self._rmsdB = {} # hash of channel, rmsdB value
  66.         self._peakdB = 0.0 # highest value over all channels for this time
  67.  
  68.         # results over the whole file
  69.         self._meansquaresums = [] # list of time -> mean square sum value
  70.         self._peaksdB = [] # list of time -> peak value
  71.  
  72.         self._lasttime = 0
  73.  
  74.         # will be set when done
  75.         self.mixin = 0
  76.         self.mixout = 0
  77.         self.length = 0
  78.         self.rms = 0.0
  79.         self.rmsdB = 0.0
  80.  
  81.     def _sourcePadAddedCb(self, source, pad):
  82.         self._source.link(self._level)
  83.  
  84.     def do_handle_message(self, message):
  85.         self.debug("got message %r" % message)
  86.         if (message.type == gst.MESSAGE_ELEMENT) and (message.src == self._level):
  87.             struc = message.structure
  88.             endtime = struc["endtime"]
  89.             rmss = struc["rms"]
  90.             peaks = struc["peak"]
  91.             decays = struc["decay"]
  92.             infos = zip(rmss, peaks, decays)
  93.             channid = 0
  94.             for rms,peak,decay in infos:
  95.                 self._level_cb(message.src, endtime, channid, rms, peak, decay)
  96.                 channid += 1
  97.         elif message.type == gst.MESSAGE_EOS:
  98.             self._eos_cb(message.src)
  99.         # chaining up 
  100.         gst.Pipeline.do_handle_message(self, message)
  101.  
  102.     def _level_cb(self, element, time, channel, rmsdB, peakdB, decaydB):
  103.         # rms is being signalled in dB
  104.         # FIXME: maybe level should have a way of signalling actual values
  105.         # signals are received in order, so I should get each channel one
  106.         # by one
  107.         if time > self._lasttime and self._lasttime > 0:
  108.             # we have a new time point, so calculate stuff for the old block
  109.             meansquaresum = 0.0
  110.             for i in self._rmsdB.keys():
  111.                 meansquaresum += math.pow(10, self._rmsdB[i] / 10.0)
  112.             # average over channels
  113.             meansquaresum /= len(self._rmsdB.keys())
  114.             try:
  115.                 rmsdBstr = str(10 * math.log10(meansquaresum))
  116.             except OverflowError:
  117.                 rmsdBstr = "(-inf)"
  118.             gst.log("meansquaresum %f (%s dB)" % (meansquaresum, rmsdBstr))
  119.  
  120.             # update values
  121.             self._peaksdB.append((self._lasttime, peakdB))
  122.             self._meansquaresums.append((self._lasttime, meansquaresum))
  123.             self._rmsdB = {}
  124.             self._peakdB = 0.0
  125.  
  126.         # store the current values for later processing
  127.         gst.log("time %s, channel %d, rmsdB %f" % (gst.TIME_ARGS(time), channel, rmsdB))
  128.         self._lasttime = time
  129.         self._rmsdB[channel] = rmsdB
  130.         if peakdB > self._peakdB:
  131.             self._peakdB = peakdB
  132.  
  133.     def _done_cb(self, source, reason):
  134.         gst.debug("done, reason %s" % reason)
  135.         # we ignore eos because we want the whole pipeline to eos
  136.         if reason == EOS:
  137.             return
  138.         self.emit('done', reason)
  139.  
  140.     def _eos_cb(self, source):
  141.         gst.debug("eos, start calcing")
  142.  
  143.         # get the highest peak RMS for this track
  144.         highestdB = self._peaksdB[0][1]
  145.  
  146.         for (time, peakdB) in self._peaksdB:
  147.             if peakdB > highestdB:
  148.                 highestdB = peakdB
  149.         gst.debug("highest peak(dB): %f" % highestdB)
  150.  
  151.         # get the length
  152.         (self.length, peakdB) = self._peaksdB[-1]
  153.         
  154.         # find the mix in point
  155.         for (time, peakdB) in self._peaksdB:
  156.             gst.log("time %s, peakdB %f" % (gst.TIME_ARGS(time), peakdB))
  157.             if peakdB > self._thresholddB + highestdB:
  158.                 gst.debug("found mix-in point of %f dB at %s" % (
  159.                     peakdB, gst.TIME_ARGS(time)))
  160.                 self.mixin = time
  161.                 break
  162.  
  163.         # reverse and find out point
  164.         self._peaksdB.reverse()
  165.         found = None
  166.         for (time, peakdB) in self._peaksdB:
  167.             if found:
  168.                 self.mixout = time
  169.                 gst.debug("found mix-out point of %f dB right before %s" % (
  170.                     found, gst.TIME_ARGS(time)))
  171.                 break
  172.                 
  173.             if peakdB > self._thresholddB + highestdB:
  174.                 found = peakdB
  175.  
  176.         # now calculate RMS between these two points
  177.         weightedsquaresums = 0.0
  178.         lasttime = self.mixin
  179.         for (time, meansquaresum) in self._meansquaresums:
  180.             if time <= self.mixin:
  181.                 continue
  182.  
  183.             delta = time - lasttime
  184.             weightedsquaresums += meansquaresum * delta
  185.             gst.log("added MSS %f over time %s at time %s, now %f" % (
  186.                 meansquaresum, gst.TIME_ARGS(delta),
  187.                 gst.TIME_ARGS(time), weightedsquaresums))
  188.  
  189.             lasttime = time
  190.             
  191.             if time > self.mixout:
  192.                 break
  193.  
  194.         # calculate
  195.         try:
  196.             ms = weightedsquaresums / (self.mixout - self.mixin)
  197.         except ZeroDivisionError:
  198.             # this is possible when, for example, the whole sound file is
  199.             # empty
  200.             gst.warning('ZeroDivisionError on %s, mixin %s, mixout %s' % (
  201.                 self._filename, gst.TIME_ARGS(self.mixin),
  202.                 gst.TIME_ARGS(self.mixout)))
  203.             self.emit('done', WRONG_TYPE)
  204.             return
  205.  
  206.         self.rms = math.sqrt(ms)
  207.         self.rmsdB = 10 * math.log10(ms)
  208.  
  209.         self.emit('done', EOS)
  210.  
  211.     def start(self):
  212.         gst.debug("Setting to PLAYING")
  213.         self.set_state(gst.STATE_PLAYING)
  214.         gst.debug("Set to PLAYING")
  215.  
  216.     # FIXME: we might want to do this ourselves automatically ?
  217.     def stop(self):
  218.         """
  219.         Stop the leveller, freeing all resources.
  220.         Call after the leveller emitted 'done' to clean up.
  221.         """
  222.         gst.debug("Setting to NULL")
  223.         self.set_state(gst.STATE_NULL)
  224.         gst.debug("Set to NULL")
  225.         utils.gc_collect('Leveller.stop()')
  226.  
  227.     def clean(self):
  228.         # clean ourselves up completely
  229.         self.stop()
  230.         # let's be ghetto and clean out our bin manually
  231.         self.remove(self._source)
  232.         self.remove(self._level)
  233.         self.remove(self._fakesink)
  234.         gst.debug("Emptied myself")
  235.         self._source.clean()
  236.         utils.gc_collect('Leveller.clean() cleaned up source')
  237.         self._source = None
  238.         self._fakesink = None
  239.         self._level = None
  240.         utils.gc_collect('Leveller.clean() done')
  241.  
  242. gobject.type_register(Leveller)
  243.  
  244. if __name__ == "__main__":
  245.     main = gobject.MainLoop()
  246.  
  247.     try:
  248.         leveller = Leveller(sys.argv[1])
  249.     except IndexError:
  250.         sys.stderr.write("Please give a file to calculate level of\n")
  251.         sys.exit(1)
  252.  
  253.     print "Starting"
  254.     bus = leveller.get_bus()
  255.     bus.add_signal_watch()
  256.     dontstop = True
  257.  
  258.     leveller.set_state(gst.STATE_PLAYING)
  259.     
  260.     while dontstop:
  261.         message = bus.poll(gst.MESSAGE_ANY, gst.SECOND)
  262.         if message:
  263.             gst.debug("got message from poll:%s/%r" % (message.type, message))
  264.         else:
  265.             gst.debug("got NOTHING from poll")
  266.         if message:
  267.             if message.type == gst.MESSAGE_EOS:
  268.                 print "in: %s, out: %s, length: %s" % (gst.TIME_ARGS(leveller.mixin),
  269.                                                        gst.TIME_ARGS(leveller.mixout),
  270.                                                        gst.TIME_ARGS(leveller.length))
  271.                 print "rms: %f, %f dB" % (leveller.rms, leveller.rmsdB)
  272.                 dontstop = False
  273.             elif message.type == gst.MESSAGE_ERROR:
  274.                 error,debug = message.parse_error()
  275.                 print "ERROR[%s] %s" % (error.domain, error.message)
  276.                 dontstop = False
  277.  
  278.     leveller.stop()
  279.     leveller.clean()
  280.  
  281.     gst.debug('deleting leveller, verify objects are freed')
  282.     utils.gc_collect('quit main loop')
  283.     del leveller
  284.     utils.gc_collect('deleted leveller')
  285.     gst.debug('stopping forever')
  286.